High-Level Code Optimization

Software systems are inherently complex. Building large software systems has proved so difficult precisely because of the complexity levels with which programmers have to deal. In [7] Brooks divides complexity in essential and accidental and argues that solutions which worked in other fields cannot apply to software. Essential complexity stems from very nature of software (i.e. the large number of states, changeability, invisibility), while accidental complexity comes from the abstraction gap between problem domain and the low level operations provided by the hardware. An important step forward are high-level languages, which help minimize accidental complexity and give good tools to manage essential complexity through abstraction. Functional and object–oriented languages provide good means for abstraction, but such features come at a cost: they are generally slower than traditional, imperative languages like C and Fortran. This can make developers avoid some of the costly constructions, or even rely on the afore-mentioned languages for reasons of efficiency (system programming comes as a good example), which of course hurts maintainability and understandability of such programs. Optimization should remove as much as possible from the cost associated with the use of high–level constructs—especially in the cases when their added flexibility is never used. Ideally the programmer should “only pay for what he uses”. Traditional optimization techniques [1] work well for improving computational inefficiency of the kind encountered in imperative constructs, but fall short in the face of closures, polymorphic calls, generics, etc. features commonly found in modern programming languages. They require specific methods that operate at a similar level of abstraction, rather than the “raw” processor model (which concerns arithmetic operations or register manipulations). Scala[10] is a new language that fuses concepts from object-oriented and functional languages. It provides features such as higher order functions, closures, currying, pattern matching, which are commonly found in functional languages, but also classes and objects, a powerful mix-in composition as replacement for multiple inheritance – the object–oriented features. All these are complemented by a powerful type system, that allows to express programs in a concise and elegant, yet type-safe way [12]. The current implementation suffers from the previously noted inefficiencies, and provides good ground for implementation and evaluation of optimization techniques that target such constructs. It is the goal of this thesis to design and test several optimizations for Scala and evaluate their performance with respect to the current implementation.